home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / nfsmount / nfsAttr.c < prev    next >
C/C++ Source or Header  |  1991-09-10  |  13KB  |  403 lines
  1. /*
  2.  * nfsAttr.c --
  3.  * 
  4.  *    Attribute handling for NFS access.
  5.  *
  6.  * Copyright 1988 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15. #ifndef lint
  16. static char rcsid[] = "$Header: /sprite/src/cmds/nfsmount/RCS/nfsAttr.c,v 1.10 91/09/10 19:24:56 mottsmth Exp $ SPRITE (Berkeley)";
  17. #endif not lint
  18.  
  19. #include "stdio.h"
  20.  
  21. #include "nfs.h"
  22. #include "sys/stat.h"
  23. #include "kernel/fslcl.h"
  24.  
  25. typedef struct SavedCookie {
  26.     int offset;
  27.     nfscookie cookie;
  28.     struct SavedCookie *next;
  29. } SavedCookie;
  30.  
  31. void NfsToSpriteAttr();
  32. void SpriteToNFsAttr();
  33.  
  34. /*
  35.  *----------------------------------------------------------------------
  36.  *
  37.  * NfsToSpriteDirectory --
  38.  *
  39.  *    Convert from an XDR list of directory entries to a Sprite directory.
  40.  *
  41.  * Results:
  42.  *    This fills in the buffer with a Sprite format directory.
  43.  *
  44.  * Side effects:
  45.  *    This saves the last nfscookie for use with the next READIR rpc.
  46.  *
  47.  *----------------------------------------------------------------------
  48.  */
  49. void
  50. NfsToSpriteDirectory(dirListPtr, offset, countPtr, buffer, fileIDPtr)
  51.     dirlist *dirListPtr;
  52.     int offset;
  53.     int *countPtr;
  54.     char *buffer;
  55.     Fs_FileID *fileIDPtr;
  56. {
  57.     register int count = 0;
  58.     register entry *entryPtr;
  59.     register Fslcl_DirEntry *spriteEntryPtr;
  60.     register int nameLength;
  61.     entry *tempEntryPtr;
  62.  
  63.     /* At one time we checked the dirListPtr->eof flag and bailed
  64.        out early if it was set.  Unfortunately, Sys V sets this
  65.        flag even when it returns some directory entries to indicate
  66.        that a subsequent request will fail.  So now we rely on 
  67.        the dirListPtr->entries ptr being NULL to indicate no entries.
  68.     */
  69.  
  70.     entryPtr = dirListPtr->entries;
  71.     spriteEntryPtr = (Fslcl_DirEntry *)buffer;
  72.     while (entryPtr != (entry *)NULL) {
  73.     nameLength = strlen(entryPtr->name);
  74.     spriteEntryPtr->fileNumber = entryPtr->fileid;
  75.     spriteEntryPtr->nameLength = nameLength;
  76.     strcpy(spriteEntryPtr->fileName, entryPtr->name);
  77.     /* The xdr routines do implicit mallocs which were never
  78.        getting freed so I added these two lines. Maybe it 
  79.        should be done with XDR_FREE ? */
  80.     free(entryPtr->name);
  81.     entryPtr->name = (filename)NULL;
  82.     if (entryPtr->nextentry != (entry *)NULL) {
  83.         spriteEntryPtr->recordLength = Fslcl_DirRecLength(nameLength);
  84.         count += spriteEntryPtr->recordLength;
  85.         spriteEntryPtr = (Fslcl_DirEntry *)((int)spriteEntryPtr +
  86.                         spriteEntryPtr->recordLength);
  87.     } else {
  88.         /* 
  89.          * Make the last entry go up to the end of the directory block.
  90.          * We save the last cookie to support sequential reading of the
  91.          * directory.  To be completely genernal we'd have to save the
  92.          * complete list of cookie/offset pairs.
  93.          */
  94.         register int extraRoom;
  95.         SavedCookie *savedCookie;
  96.  
  97.         extraRoom = FSLCL_DIR_BLOCK_SIZE - (count % FSLCL_DIR_BLOCK_SIZE);
  98.         spriteEntryPtr->recordLength = extraRoom;
  99.         count += extraRoom;
  100.         /*
  101.          * Push a saved cookie onto a list hanging from the major field.
  102.          */
  103.         savedCookie = (SavedCookie *)malloc(sizeof(SavedCookie));
  104.         savedCookie->offset = offset + count;
  105.         bcopy((char *)&entryPtr->cookie, (char *)&savedCookie->cookie,
  106.             sizeof(nfscookie));
  107.         savedCookie->next = (SavedCookie *)fileIDPtr->major;
  108.         fileIDPtr->major = (int)savedCookie;
  109.     }
  110.     /* Also, the implicitly acquired dirlist space wasn't going away,
  111.        so we'll zap it here. JMS */
  112.     tempEntryPtr = entryPtr;
  113.     entryPtr = entryPtr->nextentry;
  114.     free(tempEntryPtr);
  115.     }
  116.     *countPtr = count;
  117. }
  118.  
  119. /*
  120.  *----------------------------------------------------------------------
  121.  *
  122.  * NfsFindCookie --
  123.  *
  124.  *    Look through the list of savedCookie that are hung off the
  125.  *    fileID.major field of a directory to find one that corresponds
  126.  *    to the given offset.
  127.  *
  128.  * Results:
  129.  *    None.
  130.  *
  131.  * Side effects:
  132.  *    None.
  133.  *
  134.  *----------------------------------------------------------------------
  135.  */
  136. void
  137. NfsFindCookie(fileIDPtr, offset, cookiePtr)
  138.     Fs_FileID *fileIDPtr;
  139.     int offset;
  140.     nfscookie *cookiePtr;
  141. {
  142.     register SavedCookie *savedCookiePtr;
  143.     register SavedCookie *savedCookiePtrTrail = (SavedCookie *)NULL;
  144.     int badCookie = -1;
  145.  
  146.     savedCookiePtr = (SavedCookie *)fileIDPtr->major;
  147.     while (savedCookiePtr != (SavedCookie *)NULL) {
  148.     if (savedCookiePtr->offset == offset) {
  149.         bcopy((char *)&savedCookiePtr->cookie, (char *)cookiePtr,
  150.         sizeof(nfscookie));
  151.         /* Add code to release cookie so we don't lose heap space. JMS */
  152.         if (savedCookiePtrTrail == (SavedCookie *)NULL) {
  153.         fileIDPtr->major = (int)savedCookiePtr->next;
  154.         } else {
  155.         savedCookiePtrTrail->next = savedCookiePtr->next;
  156.         }
  157.         free((char *)savedCookiePtr);
  158.         return;
  159.     }
  160.     savedCookiePtrTrail = savedCookiePtr;
  161.     savedCookiePtr = savedCookiePtr->next;
  162.     }
  163.     printf("NfsFindCookie: no directory cookie for offset %d\n");
  164.     bcopy((char *)&badCookie, (char *)cookiePtr, sizeof(nfscookie));
  165. }
  166.  
  167. /*
  168.  *----------------------------------------------------------------------
  169.  *
  170.  * NfsGetAttrStream --
  171.  *
  172.  *    The default GetAttributes handling procedure called when an
  173.  *    PDEV_GET_ATTR request is received over a request stream.
  174.  *
  175.  * Results:
  176.  *    None.
  177.  *
  178.  * Side effects
  179.  *    None.
  180.  *
  181.  *----------------------------------------------------------------------
  182.  */
  183. /*ARGSUSED*/
  184. ReturnStatus
  185. NfsGetAttrStream(streamPtr, spriteAttrPtr, selectBitsPtr)
  186.     Pdev_Stream *streamPtr;
  187.     Fs_Attributes *spriteAttrPtr;
  188.     int *selectBitsPtr;
  189. {
  190.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  191.     register nfs_fh *handlePtr;
  192.     register int status;
  193.     NfsState *nfsPtr;
  194.     attrstat attrStat;
  195.  
  196.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  197.     handlePtr = nfsFileTable[fileIDPtr->minor]->handlePtr;
  198.     nfsPtr = (NfsState *)fileIDPtr->serverID;
  199.     nfsPtr->nfsClnt->cl_auth = nfsFileTable[fileIDPtr->minor]->authPtr;
  200.  
  201.     if (clnt_call(nfsPtr->nfsClnt, NFSPROC_GETATTR, xdr_nfs_fh, handlePtr,
  202.             xdr_attrstat, &attrStat, nfsTimeout) != RPC_SUCCESS) {
  203.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_GETATTR");
  204.         status = FAILURE;
  205.     } else {
  206.         status = attrStat.status;
  207.         if (status == NFS_OK) {
  208.         NfsToSpriteAttr(&attrStat.attrstat_u.attributes, spriteAttrPtr);
  209.         } else {
  210.         status = NfsStatusMap(status);
  211.         }
  212.     }
  213.     } else {
  214.     printf("NfsGetAttrStream: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  215.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  216.     status = FAILURE;
  217.     }
  218.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  219.     return(status);
  220. }
  221. /*
  222.  *----------------------------------------------------------------------
  223.  *
  224.  * NfsToSpriteAttr --
  225.  *
  226.  *    Map from NFS to Sprite attributes.
  227.  *
  228.  * Results:
  229.  *    Fills in the Sprite attributes from the NFS ones.
  230.  *
  231.  * Side effects
  232.  *    None.
  233.  *
  234.  *----------------------------------------------------------------------
  235.  */
  236. void
  237. NfsToSpriteAttr(nfsAttrPtr, spriteAttrPtr)
  238.     register fattr *nfsAttrPtr;
  239.     register Fs_Attributes *spriteAttrPtr;
  240. {
  241.     spriteAttrPtr->serverID        = -1;
  242.     spriteAttrPtr->domain        = nfsAttrPtr->fsid;
  243.     spriteAttrPtr->fileNumber        = nfsAttrPtr->fileid;
  244.     spriteAttrPtr->type            = nfsToSpriteFileType[(int) nfsAttrPtr->type];
  245.     spriteAttrPtr->size            = nfsAttrPtr->size;
  246.     spriteAttrPtr->numLinks        = nfsAttrPtr->nlink;
  247.     spriteAttrPtr->permissions        = nfsAttrPtr->mode & 07777;
  248.     spriteAttrPtr->uid            = nfsAttrPtr->uid;
  249.     spriteAttrPtr->gid            = nfsAttrPtr->gid;
  250.     spriteAttrPtr->devServerID        = -1;
  251.     if (nfsAttrPtr->type == NFBLK || nfsAttrPtr->type == NFCHR) {
  252.     spriteAttrPtr->devType        = unix_major(nfsAttrPtr->rdev);
  253.     spriteAttrPtr->devUnit        = unix_minor(nfsAttrPtr->rdev);
  254.     } else {
  255.     spriteAttrPtr->devType        = -1;
  256.     spriteAttrPtr->devUnit        = -1;
  257.     }
  258.     spriteAttrPtr->createTime.seconds        = nfsAttrPtr->mtime.seconds;
  259.     spriteAttrPtr->createTime.microseconds    = nfsAttrPtr->mtime.useconds;
  260.     spriteAttrPtr->accessTime.seconds        = nfsAttrPtr->atime.seconds;
  261.     spriteAttrPtr->accessTime.microseconds    = nfsAttrPtr->atime.useconds;
  262.     spriteAttrPtr->descModifyTime.seconds    = nfsAttrPtr->ctime.seconds;
  263.     spriteAttrPtr->descModifyTime.microseconds    = nfsAttrPtr->ctime.useconds;
  264.     spriteAttrPtr->dataModifyTime.seconds    = nfsAttrPtr->mtime.seconds;
  265.     spriteAttrPtr->dataModifyTime.microseconds    = nfsAttrPtr->mtime.useconds;
  266.     /*
  267.      * Sprite "blocks" means 1K.  Unix "blocks" mean 512 bytes.
  268.      * In both cases, blocksize is the file system block size, which
  269.      * has nothing to do with the units of the blocksize field!
  270.      */
  271.     spriteAttrPtr->blocks        = nfsAttrPtr->blocks / 2;
  272.     spriteAttrPtr->blockSize        = nfsAttrPtr->blocksize;
  273.     spriteAttrPtr->version        = nfsAttrPtr->mtime.seconds;
  274.     spriteAttrPtr->userType        = 0;
  275. }
  276.  
  277. /*
  278.  *----------------------------------------------------------------------
  279.  *
  280.  * NfsSetAttrStream --
  281.  *
  282.  *    PDEV_SET_ATTR callback to set attributes of an open NFS file.
  283.  *
  284.  * Results:
  285.  *    None.
  286.  *
  287.  * Side effects
  288.  *    None.
  289.  *
  290.  *----------------------------------------------------------------------
  291.  */
  292. /*ARGSUSED*/
  293. ReturnStatus
  294. NfsSetAttrStream(streamPtr, flags, uid, gid, spriteAttrPtr, selectBitsPtr)
  295.     Pdev_Stream *streamPtr;
  296.     int flags;            /* What attributes to set */
  297.     int uid;            /* UserID of process doing the set attr */
  298.     int gid;            /* GroupID of process doing the set attr */
  299.     Fs_Attributes *spriteAttrPtr;
  300.     int *selectBitsPtr;
  301. {
  302.     register Fs_FileID *fileIDPtr = (Fs_FileID *)streamPtr->clientData;
  303.     register nfs_fh *handlePtr;
  304.     register int status;
  305.     NfsState *nfsPtr;
  306.     sattrargs sattrArgs;
  307.     attrstat attrStat;
  308.  
  309.     if (fileIDPtr->minor >= 0 && fileIDPtr->minor < nfsFileTableSize) {
  310.     handlePtr = nfsFileTable[fileIDPtr->minor]->handlePtr;
  311.     nfsPtr = (NfsState *)fileIDPtr->serverID;
  312.     nfsPtr->nfsClnt->cl_auth = nfsFileTable[fileIDPtr->minor]->authPtr;
  313.  
  314.     bcopy((char *)handlePtr, (char *)&sattrArgs.file, sizeof(nfs_fh));
  315.     SpriteToNfsAttr(flags, spriteAttrPtr, &sattrArgs.attributes);
  316.     if (clnt_call(nfsPtr->nfsClnt, NFSPROC_SETATTR, xdr_sattrargs,
  317.             &sattrArgs, xdr_attrstat, &attrStat, nfsTimeout)
  318.             != RPC_SUCCESS) {
  319.         clnt_perror(nfsPtr->nfsClnt, "NFSPROC_SETATTR");
  320.         status = FAILURE;
  321.     } else {
  322.         status = NfsStatusMap(((int)attrStat.status));
  323.     }
  324.     } else {
  325.     printf("NfsSetAttrStream: bad fileID <%d,%d,%d,%d>\n", fileIDPtr->type,
  326.         fileIDPtr->serverID, fileIDPtr->major, fileIDPtr->minor);
  327.     status = FAILURE;
  328.     }
  329.     *selectBitsPtr = FS_READABLE | FS_WRITABLE;
  330.     return(status);
  331. }
  332.  
  333. /*
  334.  *----------------------------------------------------------------------
  335.  *
  336.  * SpriteToNfsAttr --
  337.  *
  338.  *    Map from Sprite to NFS attributes.
  339.  *
  340.  * Results:
  341.  *    Fills in the NFS attributes from the Sprite ones.
  342.  *
  343.  * Side effects
  344.  *    None.
  345.  *
  346.  *----------------------------------------------------------------------
  347.  */
  348. void
  349. SpriteToNfsAttr(flags, spriteAttrPtr, nfsAttrPtr)
  350.     register int flags;            /* Indicate which attrs to set */
  351.     register Fs_Attributes *spriteAttrPtr;
  352.     register sattr *nfsAttrPtr;
  353. {
  354.     if (flags & FS_SET_MODE) {
  355.     nfsAttrPtr->mode = spriteAttrPtr->permissions & 07777;
  356.     } else {
  357.     nfsAttrPtr->mode = -1;
  358.     }
  359.     if (flags & FS_SET_OWNER) {
  360.     nfsAttrPtr->uid        = spriteAttrPtr->uid;
  361.     nfsAttrPtr->gid        = spriteAttrPtr->gid;
  362.     } else {
  363.     nfsAttrPtr->uid        = -1;
  364.     nfsAttrPtr->gid        = -1;
  365.     }
  366.     nfsAttrPtr->size        = -1;        /* Not used for truncate */
  367.     if (flags & FS_SET_TIMES) {
  368.     nfsAttrPtr->atime.seconds  = spriteAttrPtr->accessTime.seconds;
  369.     nfsAttrPtr->atime.useconds = spriteAttrPtr->accessTime.microseconds;
  370.     nfsAttrPtr->mtime.seconds  = spriteAttrPtr->dataModifyTime.seconds;
  371.     nfsAttrPtr->mtime.useconds = spriteAttrPtr->dataModifyTime.microseconds;
  372.     } else {
  373.     nfsAttrPtr->atime.seconds  = -1;
  374.     nfsAttrPtr->atime.useconds = -1;
  375.     nfsAttrPtr->mtime.seconds  = -1;
  376.     nfsAttrPtr->mtime.useconds = -1;
  377.     }
  378. }
  379.  
  380. /*
  381.  *----------------------------------------------------------------------
  382.  *
  383.  * NfsCacheAttributes --
  384.  *
  385.  *    Cache NFS attributes.
  386.  *
  387.  * Results:
  388.  *    None.
  389.  *
  390.  * Side effects
  391.  *    Tucks away the attributes with a coarse date stamp.
  392.  *
  393.  *----------------------------------------------------------------------
  394.  */
  395. void
  396. NfsCacheAttributes(fileIDPtr, nfsAttrPtr)
  397.     register Fs_FileID *fileIDPtr;
  398.     register fattr *nfsAttrPtr;
  399. {
  400.     return;
  401. }
  402.  
  403.